# -*- coding: utf-8 -*-
"""
用户社交功能接口
"""
from flask import Blueprint, request, jsonify, current_app, g
from flasgger import swag_from
from app import db
from app.models.user import User
from app.models.user_relation import UserRelation
from app.utils.response import success_response, error_response
from app.utils.decorators import login_required
from datetime import datetime

social_bp = Blueprint('user_social', __name__)

@social_bp.route('/friends', methods=['GET'])
@login_required
@swag_from({
    'tags': ['用户-社交'],
    'summary': '获取用户关系列表',
    'description': '用户查看自己的好友列表、黑名单或全部关系列表',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}，从登录接口获取'
        },
        {
            'name': 'page',
            'in': 'query',
            'type': 'integer',
            'default': 1,
            'description': '页码'
        },
        {
            'name': 'per_page',
            'in': 'query',
            'type': 'integer',
            'default': 10,
            'description': '每页数量'
        },
        {
            'name': 'keyword',
            'in': 'query',
            'type': 'string',
            'description': '搜索关键词（用户昵称）'
        },
        {
            'name': 'list_type',
            'in': 'query',
            'type': 'string',
            'enum': ['friend', 'blacklist', 'all'],
            'description': '列表类型：friend=好友列表(白名单)，blacklist=黑名单，all=全部关系列表。不传参数默认为all'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'total': {'type': 'integer', 'description': '用户关系总数'},
                            'page': {'type': 'integer'},
                            'pages': {'type': 'integer'},
                            'list_type': {'type': 'string', 'description': '当前查询的列表类型'},
                            'relations': {
                                'type': 'array',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'relation_id': {'type': 'integer'},
                                        'relation_type': {'type': 'string', 'description': '关系类型：friend或blacklist'},
                                        'user': {
                                            'type': 'object',
                                            'properties': {
                                                'id': {'type': 'integer'},
                                                'nickname': {'type': 'string'},
                                                'avatar_url': {'type': 'string'},
                                                'gender': {'type': 'integer'}
                                            }
                                        },
                                        'is_friend': {'type': 'boolean', 'description': '是否为好友关系'},
                                        'is_blacklisted': {'type': 'boolean', 'description': '是否在黑名单中'},
                                        'created_at': {'type': 'string', 'description': '关系建立时间'}
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
})
def get_friends():
    """获取用户关系列表（好友、黑名单或全部）"""
    try:
        page = request.args.get('page', 1, type=int)
        per_page = min(request.args.get('per_page', 10, type=int), 50)
        keyword = request.args.get('keyword', '').strip()
        list_type = request.args.get('list_type', 'all').strip().lower()
        
        # 验证list_type参数
        valid_types = ['friend', 'blacklist', 'all']
        if list_type not in valid_types:
            list_type = 'all'
        
        # 构建基础查询
        query = UserRelation.query.filter_by(
            owner_id=int(g.current_user_id)
        ).join(User, UserRelation.target_id == User.id)
        
        # 根据list_type过滤
        if list_type == 'friend':
            query = query.filter(UserRelation.relation_type == 'friend')
        elif list_type == 'blacklist':
            query = query.filter(UserRelation.relation_type == 'blacklist')
        # list_type == 'all' 不需要额外过滤
        
        # 搜索过滤
        if keyword:
            query = query.filter(User.nickname.like(f'%{keyword}%'))
        
        # 分页查询
        pagination = query.order_by(UserRelation.created_at.desc()).paginate(
            page=page, per_page=per_page, error_out=False
        )
        
        relations = []
        for relation in pagination.items:
            try:
                # 获取用户信息
                user_data = relation.target.to_dict() if relation.target else None
                if not user_data:
                    continue
                
                # 判断关系状态
                is_friend = relation.relation_type == 'friend'
                is_blacklisted = relation.relation_type == 'blacklist'
                
                relation_data = {
                    'relation_id': relation.id,
                    'relation_type': relation.relation_type,
                    'user': user_data,
                    'is_friend': is_friend,
                    'is_blacklisted': is_blacklisted,
                    'created_at': relation.created_at.strftime('%Y-%m-%d %H:%M:%S') if relation.created_at else None
                }
                relations.append(relation_data)
            except Exception as e:
                current_app.logger.warning(f"处理用户关系 {relation.id} 时出错: {str(e)}")
                continue
        
        return success_response({
            'total': pagination.total,
            'page': page,
            'pages': pagination.pages,
            'list_type': list_type,
            'relations': relations
        }, '获取成功')
        
    except Exception as e:
        import traceback
        current_app.logger.error(f"获取用户关系列表失败: {str(e)}")
        current_app.logger.error(f"完整错误信息: {traceback.format_exc()}")
        return error_response('获取失败', 500)

@social_bp.route('/friends/<int:user_id>', methods=['POST'])
@login_required
@swag_from({
    'tags': ['用户-社交'],
    'summary': '添加好友',
    'description': '用户添加好友',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}，从登录接口获取'
        },
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '要添加为好友的用户ID'
        }
    ],
    'responses': {
        200: {'description': '添加成功'},
        400: {'description': '参数错误或重复添加'},
        404: {'description': '用户不存在'}
    }
})
def add_friend(user_id):
    """添加好友"""
    try:
        # 验证用户存在
        target_user = User.query.get(user_id)
        if not target_user or not target_user.is_active:
            return error_response('用户不存在或已被禁用', 404)
        
        # 不能添加自己为好友
        if user_id == int(g.current_user_id):
            return error_response('不能添加自己为好友', 400)
        
        # 检查是否已经是好友
        if UserRelation.is_friend(int(g.current_user_id), user_id):
            return error_response('该用户已经是您的好友', 400)
        
        # 检查是否在黑名单中
        if UserRelation.is_blacklisted(int(g.current_user_id), user_id):
            return error_response('请先从黑名单中移除该用户', 400)
        
        # 添加好友关系
        UserRelation.set_relation(int(g.current_user_id), user_id, 'friend')
        db.session.commit()
        
        return success_response({
            'user_id': user_id,
            'nickname': target_user.nickname
        }, '添加好友成功')
        
    except ValueError as e:
        return error_response(str(e), 400)
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"添加好友失败: {str(e)}")
        return error_response('添加好友失败', 500)

@social_bp.route('/friends/<int:user_id>', methods=['DELETE'])
@login_required
@swag_from({
    'tags': ['用户-社交'],
    'summary': '删除好友',
    'description': '用户删除好友',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}，从登录接口获取'
        },
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '要删除的好友用户ID'
        }
    ],
    'responses': {
        200: {'description': '删除成功'},
        404: {'description': '好友关系不存在'}
    }
})
def remove_friend(user_id):
    """删除好友"""
    try:
        # 删除好友关系
        success = UserRelation.delete_user_relation(int(g.current_user_id), 'friend', user_id)
        
        if not success:
            return error_response('好友关系不存在', 404)
        
        db.session.commit()
        
        return success_response({'user_id': user_id}, '删除好友成功')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"删除好友失败: {str(e)}")
        return error_response('删除好友失败', 500)

@social_bp.route('/blacklist', methods=['GET'])
@login_required
@swag_from({
    'tags': ['用户-社交'],
    'summary': '获取黑名单列表',
    'description': '用户查看自己的黑名单列表',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}，从登录接口获取'
        },
        {
            'name': 'page',
            'in': 'query',
            'type': 'integer',
            'default': 1,
            'description': '页码'
        },
        {
            'name': 'per_page',
            'in': 'query',
            'type': 'integer',
            'default': 10,
            'description': '每页数量'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'total': {'type': 'integer', 'description': '黑名单总数'},
                            'page': {'type': 'integer'},
                            'pages': {'type': 'integer'},
                            'blacklist': {
                                'type': 'array',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'relation_id': {'type': 'integer'},
                                        'user': {
                                            'type': 'object',
                                            'properties': {
                                                'id': {'type': 'integer'},
                                                'nickname': {'type': 'string'},
                                                'avatar_url': {'type': 'string'}
                                            }
                                        },
                                        'created_at': {'type': 'string', 'description': '加入时间'}
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
})
def get_blacklist():
    """获取黑名单列表"""
    try:
        page = request.args.get('page', 1, type=int)
        per_page = min(request.args.get('per_page', 10, type=int), 50)
        
        # 查询黑名单关系
        query = UserRelation.query.filter_by(
            owner_id=int(g.current_user_id),
            relation_type='blacklist'
        ).join(User, UserRelation.target_id == User.id)
        
        # 分页查询
        pagination = query.order_by(UserRelation.created_at.desc()).paginate(
            page=page, per_page=per_page, error_out=False
        )
        
        blacklist = []
        for relation in pagination.items:
            blacklist_data = {
                'relation_id': relation.id,
                'user': {
                    'id': relation.target.id,
                    'nickname': relation.target.nickname,
                    'avatar_url': relation.target.avatar_url
                } if relation.target else None,
                'created_at': relation.created_at.strftime('%Y-%m-%d %H:%M:%S')
            }
            blacklist.append(blacklist_data)
        
        return success_response({
            'total': pagination.total,
            'page': page,
            'pages': pagination.pages,
            'blacklist': blacklist
        }, '获取成功')
        
    except Exception as e:
        current_app.logger.error(f"获取黑名单失败: {str(e)}")
        return error_response('获取失败', 500)

@social_bp.route('/blacklist/<int:user_id>', methods=['POST'])
@login_required
@swag_from({
    'tags': ['用户-社交'],
    'summary': '添加到黑名单',
    'description': '用户将其他用户添加到黑名单',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}，从登录接口获取'
        },
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '要加入黑名单的用户ID'
        }
    ],
    'responses': {
        200: {'description': '添加成功'},
        400: {'description': '参数错误或重复添加'},
        404: {'description': '用户不存在'}
    }
})
def add_to_blacklist(user_id):
    """添加到黑名单"""
    try:
        # 验证用户存在
        target_user = User.query.get(user_id)
        if not target_user:
            return error_response('用户不存在', 404)
        
        # 不能将自己加入黑名单
        if user_id == int(g.current_user_id):
            return error_response('不能将自己加入黑名单', 400)
        
        # 检查是否已经在黑名单中
        if UserRelation.is_blacklisted(int(g.current_user_id), user_id):
            return error_response('该用户已在您的黑名单中', 400)
        
        # 如果是好友关系，先删除好友关系
        if UserRelation.is_friend(int(g.current_user_id), user_id):
            UserRelation.delete_user_relation(int(g.current_user_id), 'friend', user_id)
        
        # 添加黑名单关系
        UserRelation.set_relation(int(g.current_user_id), user_id, 'blacklist')
        db.session.commit()
        
        return success_response({
            'user_id': user_id,
            'nickname': target_user.nickname
        }, '已添加到黑名单')
        
    except ValueError as e:
        return error_response(str(e), 400)
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"添加黑名单失败: {str(e)}")
        return error_response('添加黑名单失败', 500)

@social_bp.route('/blacklist/<int:user_id>', methods=['DELETE'])
@login_required
@swag_from({
    'tags': ['用户-社交'],
    'summary': '从黑名单移除',
    'description': '用户将其他用户从黑名单中移除',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}，从登录接口获取'
        },
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '要从黑名单移除的用户ID'
        }
    ],
    'responses': {
        200: {'description': '移除成功'},
        404: {'description': '黑名单关系不存在'}
    }
})
def remove_from_blacklist(user_id):
    """从黑名单移除"""
    try:
        # 删除黑名单关系
        success = UserRelation.delete_user_relation(int(g.current_user_id), 'blacklist', user_id)
        
        if not success:
            return error_response('该用户不在您的黑名单中', 404)
        
        db.session.commit()
        
        return success_response({'user_id': user_id}, '已从黑名单移除')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"移除黑名单失败: {str(e)}")
        return error_response('移除黑名单失败', 500)

@social_bp.route('/relation/<int:user_id>', methods=['GET'])
@login_required
@swag_from({
    'tags': ['用户-社交'],
    'summary': '查询用户关系',
    'description': '查询当前用户与指定用户的关系状态',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}，从登录接口获取'
        },
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '要查询关系的用户ID'
        }
    ],
    'responses': {
        200: {
            'description': '查询成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '查询成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'user_id': {'type': 'integer'},
                            'relation_type': {'type': 'string', 'enum': ['friend', 'blacklist', 'none'], 'description': '关系类型'},
                            'created_at': {'type': 'string', 'description': '关系建立时间'}
                        }
                    }
                }
            }
        }
    }
})
def get_user_relation(user_id):
    """查询用户关系"""
    try:
        if user_id == int(g.current_user_id):
            return success_response({
                'user_id': user_id,
                'relation_type': 'self',
                'created_at': None
            }, '查询成功')
        
        # 查询关系
        relation = UserRelation.get_relation(int(g.current_user_id), user_id)
        
        if relation:
            return success_response({
                'user_id': user_id,
                'relation_type': relation.relation_type,
                'created_at': relation.created_at.strftime('%Y-%m-%d %H:%M:%S')
            }, '查询成功')
        else:
            return success_response({
                'user_id': user_id,
                'relation_type': 'none',
                'created_at': None
            }, '查询成功')
        
    except Exception as e:
        current_app.logger.error(f"查询用户关系失败: {str(e)}")
        return error_response('查询失败', 500)

@social_bp.route('/search', methods=['GET'])
@login_required
@swag_from({
    'tags': ['用户-社交'],
    'summary': '搜索用户',
    'description': '根据昵称或手机号搜索用户，用于添加好友',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}，从登录接口获取'
        },
        {
            'name': 'keyword',
            'in': 'query',
            'type': 'string',
            'required': True,
            'description': '搜索关键词（昵称或手机号）'
        },
        {
            'name': 'page',
            'in': 'query',
            'type': 'integer',
            'default': 1,
            'description': '页码'
        },
        {
            'name': 'per_page',
            'in': 'query',
            'type': 'integer',
            'default': 10,
            'description': '每页数量'
        }
    ],
    'responses': {
        200: {
            'description': '搜索成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '搜索成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'total': {'type': 'integer'},
                            'users': {
                                'type': 'array',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'nickname': {'type': 'string'},
                                        'avatar_url': {'type': 'string'},
                                        'gender': {'type': 'integer'},
                                        'relation_type': {'type': 'string', 'description': '与当前用户的关系'}
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
})
def search_users():
    """搜索用户"""
    try:
        keyword = request.args.get('keyword', '').strip()
        if not keyword:
            return error_response('搜索关键词不能为空', 400)
        
        page = request.args.get('page', 1, type=int)
        per_page = min(request.args.get('per_page', 10, type=int), 50)
        
        # 搜索用户
        from sqlalchemy import or_
        query = User.query.filter(
            User.is_active == True,
            User.id != int(g.current_user_id),  # 排除自己
            or_(
                User.nickname.like(f'%{keyword}%'),
                User.phone.like(f'%{keyword}%')
            )
        )
        
        pagination = query.paginate(page=page, per_page=per_page, error_out=False)
        
        users = []
        for user in pagination.items:
            # 查询与当前用户的关系
            relation = UserRelation.get_relation(int(g.current_user_id), user.id)
            relation_type = relation.relation_type if relation else 'none'
            
            user_data = user.to_dict()
            user_data['relation_type'] = relation_type
            users.append(user_data)
        
        return success_response({
            'total': pagination.total,
            'users': users
        }, '搜索成功')
        
    except Exception as e:
        current_app.logger.error(f"搜索用户失败: {str(e)}")
        return error_response('搜索失败', 500)

@social_bp.route('/friends/<int:user_id>/profile', methods=['GET'])
@login_required
@swag_from({
    'tags': ['用户-社交'],
    'summary': '查看用户详细信息',
    'description': '查看指定用户的详细信息，任何已登录用户都可以查看',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}，从登录接口获取'
        },
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '要查看的用户ID'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'userInfo': {
                                'type': 'object',
                                'description': '用户基本信息',
                                'properties': {
                                    'id': {'type': 'integer', 'description': '用户ID'},
                                    'nickname': {'type': 'string', 'description': '昵称'},
                                    'avatar_url': {'type': 'string', 'description': '头像URL'},
                                    'gender': {'type': 'integer', 'description': '性别：0-未知，1-男，2-女'},
                                    'phone': {'type': 'string', 'description': '手机号（脱敏）'},
                                    'created_at': {'type': 'string', 'description': '注册时间'}
                                }
                            },
                            'attributes': {
                                'type': 'object',
                                'description': '用户自定义属性',
                                'additionalProperties': {'type': 'string'}
                            },
                            'relationshipInfo': {
                                'type': 'object',
                                'description': '与当前用户的关系信息',
                                'properties': {
                                    'relation_type': {'type': 'string', 'description': '关系类型：friend/blacklist/none'},
                                    'relation_id': {'type': 'integer', 'description': '关系ID（如果存在关系）'},
                                    'since': {'type': 'string', 'description': '建立关系的时间（如果存在关系）'}
                                }
                            },
                            'is_friend': {'type': 'boolean', 'description': '是否为好友关系，true表示是好友，false表示不是好友'},
                            'is_blacklisted': {'type': 'boolean', 'description': '是否为黑名单用户，true表示在黑名单中，false表示不在黑名单中'},
                            'statistics': {
                                'type': 'object',
                                'description': '用户的公开统计信息',
                                'properties': {
                                    'organized_count': {'type': 'integer', 'description': '组织活动数量'},
                                    'participated_count': {'type': 'integer', 'description': '参与活动数量'},
                                    'friends_count': {'type': 'integer', 'description': '好友数量'}
                                }
                            },
                            'commonActivities': {
                                'type': 'object',
                                'description': '共同参与的活动信息',
                                'properties': {
                                    'count': {'type': 'integer', 'description': '共同参与的活动数量'},
                                    'activities': {
                                        'type': 'array',
                                        'description': '共同参与的活动列表（最多显示5个最新的）',
                                        'items': {
                                            'type': 'object',
                                            'properties': {
                                                'id': {'type': 'integer', 'description': '活动ID'},
                                                'title': {'type': 'string', 'description': '活动标题'},
                                                'description': {'type': 'string', 'description': '活动描述'},
                                                'start_time': {'type': 'string', 'description': '开始时间'},
                                                'end_time': {'type': 'string', 'description': '结束时间'},
                                                'status': {'type': 'string', 'description': '活动状态'},
                                                'venue_name': {'type': 'string', 'description': '场馆名称'},
                                                'organizer': {
                                                    'type': 'object',
                                                    'properties': {
                                                        'id': {'type': 'integer'},
                                                        'nickname': {'type': 'string'},
                                                        'avatar_url': {'type': 'string'}
                                                    }
                                                },
                                                'joined_at_current_user': {'type': 'string', 'description': '当前用户参与时间'},
                                                'joined_at_target_user': {'type': 'string', 'description': '目标用户参与时间'}
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        },
        400: {
            'description': '参数错误',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 400},
                    'message': {'type': 'string', 'example': '不能查看自己的信息，请使用用户信息接口'}
                }
            }
        },
        404: {
            'description': '用户不存在',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 404},
                    'message': {'type': 'string', 'example': '用户不存在'}
                }
            }
        }
    }
})
def get_friend_profile(user_id):
    """查看用户详细信息"""
    try:
        from app.models.user_attribute import UserAttribute
        from app.models.activity import Activity, ActivityParticipant
        
        # 验证目标用户存在
        target_user = User.query.get(user_id)
        if not target_user or not target_user.is_active:
            return error_response('用户不存在或已被禁用', 404)
        
        # 不能查看自己的信息（应该使用用户信息接口）
        if user_id == int(g.current_user_id):
            return error_response('请使用用户信息接口查看自己的信息', 400)
        
        # 获取用户基本信息
        user_data = target_user.to_dict()
        
        # 脱敏处理手机号（只显示前3位和后4位）
        if user_data.get('phone'):
            phone = user_data['phone']
            if len(phone) >= 7:
                user_data['phone'] = phone[:3] + '****' + phone[-4:]
        
        # 获取用户自定义属性
        user_attributes = UserAttribute.get_user_attributes(user_id)
        
        # 获取与当前用户的关系信息
        relation = UserRelation.get_relation(int(g.current_user_id), user_id)
        if relation:
            relationship_info = {
                'relation_type': relation.relation_type,
                'relation_id': relation.id,
                'since': relation.created_at.strftime('%Y-%m-%d %H:%M:%S') if relation.created_at else None
            }
            is_friend = relation.relation_type == 'friend'
            is_blacklisted = relation.relation_type == 'blacklist'
        else:
            relationship_info = {
                'relation_type': 'none',
                'relation_id': None,
                'since': None
            }
            is_friend = False
            is_blacklisted = False
        
        # 统计用户的公开信息
        # 组织的活动数量
        organized_count = Activity.query.filter_by(
            organizer_id=user_id,
            is_active=True
        ).count()
        
        # 参与的活动数量
        participated_count = db.session.query(Activity).join(
            ActivityParticipant, Activity.id == ActivityParticipant.activity_id
        ).filter(
            ActivityParticipant.user_id == user_id,
            ActivityParticipant.status == 'joined',
            Activity.is_active == True
        ).count()
        
        # 好友数量
        friends_count = UserRelation.query.filter_by(
            owner_id=user_id,
            relation_type='friend'
        ).count()
        
        # 查询共同参与的活动
        # 查询当前用户参与的活动ID列表
        current_user_activities = db.session.query(ActivityParticipant.activity_id).filter(
            ActivityParticipant.user_id == int(g.current_user_id),
            ActivityParticipant.status == 'joined'
        ).subquery()
        
        # 查询目标用户参与的活动ID列表
        target_user_activities = db.session.query(ActivityParticipant.activity_id).filter(
            ActivityParticipant.user_id == user_id,
            ActivityParticipant.status == 'joined'
        ).subquery()
        
        # 查询共同活动（取交集）
        common_activities_query = db.session.query(Activity).join(
            current_user_activities, Activity.id == current_user_activities.c.activity_id
        ).join(
            target_user_activities, Activity.id == target_user_activities.c.activity_id
        ).filter(
            Activity.is_active == True
        ).order_by(Activity.created_at.desc())
        
        # 获取共同活动总数
        common_activities_count = common_activities_query.count()
        
        # 获取最多5个最新的共同活动详情
        common_activities_list = common_activities_query.limit(5).all()
        
        # 构建共同活动数据
        common_activities_data = []
        for activity in common_activities_list:
            # 获取当前用户的参与时间
            current_user_participation = ActivityParticipant.query.filter_by(
                activity_id=activity.id,
                user_id=int(g.current_user_id),
                status='joined'
            ).first()
            
            # 获取目标用户的参与时间
            target_user_participation = ActivityParticipant.query.filter_by(
                activity_id=activity.id,
                user_id=user_id,
                status='joined'
            ).first()
            
            # 构建活动数据
            activity_data = activity.to_dict(include_organizer=True, include_venue=True)
            activity_data['joined_at_current_user'] = current_user_participation.joined_at.strftime('%Y-%m-%d %H:%M:%S') if current_user_participation and current_user_participation.joined_at else None
            activity_data['joined_at_target_user'] = target_user_participation.joined_at.strftime('%Y-%m-%d %H:%M:%S') if target_user_participation and target_user_participation.joined_at else None
            
            common_activities_data.append(activity_data)
        
        # 构建返回数据
        response_data = {
            'userInfo': user_data,
            'attributes': user_attributes,
            'relationshipInfo': relationship_info,
            'is_friend': is_friend,
            'is_blacklisted': is_blacklisted,
            'statistics': {
                'organized_count': organized_count,
                'participated_count': participated_count,
                'friends_count': friends_count
            },
            'commonActivities': {
                'count': common_activities_count,
                'activities': common_activities_data
            }
        }
        
        return success_response(response_data, '获取用户信息成功')
        
    except Exception as e:
        import traceback
        current_app.logger.error(f"获取用户信息失败: {str(e)}")
        current_app.logger.error(f"完整错误信息: {traceback.format_exc()}")
        return error_response('获取用户信息失败', 500) 